In the field of software development, many computer programs or applications of early origin are often written in less useful and less technically powerful languages than those written today using a variety of object-oriented applications. Many of these programs, often referred to as “legacy” applications are written using earlier-developed programming languages that may be relatively difficult to use and deploy over various hardware and computing systems. Legacy applications usually have more complicated structures than their contemporary analogs. In other words, legacy applications were often more difficult to develop, maintain, and update, expensive to create, and required extensive time and developer resources than contemporary applications.
Further, many legacy programs are not optimized in terms of control flow information, which can govern how well a program executes. In programming languages like COBOL, conventional applications typically have a relatively high degree of inherent flexibility in the structure of the application. With such applications, however, developers have an increased opportunity to create applications that are structured in a manner that affects program flow control, as well as the control flow analysis as applied to legacy applications. For example, control flow analysis traditionally operates upon rooted directed graphs, in a well-structured program, each perform range can be modeled by a rooted directed graph, which normally leads to effective and efficient code optimization. But the above-described conventional techniques do not operate well on loose-structured programs, examples of which include the development of COBOL programs.
The advent of object-oriented languages, such as Java™ from Sun Microsystems™ (now a division of Oracle™), and “rich” graphical user interfaces have fueled rapid development cycles for designing, building, and programming a variety of applications for a variety of users, including end consumers and enterprises, with little to no emphasis on the hardware upon which the applications might execute. Unfortunately, legacy applications require a conversion to make them compatible with contemporary programming applications. Such conversions typically require extensive resources to convert the legacy applications to more contemporary and useful object-oriented programming schema or structures.
Conventionally, the relative flexibility in control structures inherent in legacy applications, such as COBOL, may complicate a conversion into, for example, another programming language. In particular, the relatively loose structure of COBOL can lead to unpredictable control flow of the code during execution. For example, the liberal use of “alter” statements in connection with COBOL paragraphs (i.e., an alterable paragraph) nay result in complicated and inefficient flow of executable code. Similarly, the use of instructions that change the control without properly returning control flow back to the point of origination can disrupt or complicate the flow of executable code.
Thus, what is needed is a solution for optimizing legacy applications developed using earlier computing programming languages, including COBOL without the limitations of the conventional techniques.